#include <iostream>
#include <cassert>
using namespace std;
// int global_init = 42; // 初始化数据段
// int global_uninit;    // 未初始化数据段（BSS）

// int main()
// {
//     int local = 10;                         // 栈
//     int local2 = 11;                        // 栈向下增长
//     int *heap = (int *)malloc(sizeof(int)); // 堆
//     assert(heap);
//     *heap = 20;

//     std::cout << "Global initialized: " << &global_init << std::endl;
//     std::cout << "Global uninitialized: " << &global_uninit << std::endl;
//     std::cout << "Heap: " << heap << std::endl;
//     std::cout << "Local2: " << &local2 << std::endl;
//     std::cout << "Local: " << &local << std::endl;

//     free(heap);
//     return 0;
// }

// void func(int n) {
//     int local1 = n;
//     int local2 = n + 1;
//     std::cout << "Address of local1: " << &local1 << std::endl;
//     std::cout << "Address of local2: " << &local2 << std::endl;
// }

// int main() {
//     int a = 10;
//     int b = 20;
//     std::cout << "Address of a: " << &a << std::endl;
//     std::cout << "Address of b: " << &b << std::endl;
//     func(30);
//     return 0;
// }

#include <signal.h>
// void handler(int signo)
// {
//     cout<<"Recieve a signo: "<<signo<<endl;
// }
// int main()
// {
//     signal(2,handler);
//     while(1)
//     {

//     }
//     return 0;
// }

// sigpending获取未决信号集

// void handler(int signo)
// {
//     cout<<"当前收到"<<signo<<"号信号"<<endl;
// }
// void print(const sigset_t& tmp)
// {
//     for(int i=1;i<=32;i++)
//     {
//         if(sigismember(&tmp,i))
//             cout<<1;
//         else
//             cout<<0;
//     }
//     cout<<endl;
// }
// int main()
// {
//     signal(2,handler);//自定义

//     //屏蔽2号信号
//     cout<<"mypid = "<<getpid()<<endl;
//     sigset_t set;
//     sigemptyset(&set);
//     sigaddset(&set,2);

//     // 阻塞2号信号
//     sigprocmask(SIG_BLOCK,&set,nullptr);

//     // 1.获取未决信号集合
//     sigpending(&set);
//     print(set);

//     // 2.向当前进程发送二号信号,并再次获取未决信号集合
//     kill(getpid(),2);
//     sigpending(&set);
//     print(set);

//     // 3.解除阻塞并重新获取未决信号集
//     sigprocmask(SIG_UNBLOCK,&set,nullptr);
//     sigpending(&set);
//     print(set);

//     return 0;
// }

// #include <stdio.h>
// #include <stdlib.h>
// #include <pthread.h>
// #include <signal.h>
// #include <unistd.h>

// void *thread_function(void *arg)
// {
//     sigset_t set;
//     sigemptyset(&set);
//     sigaddset(&set, SIGINT);

//     // 屏蔽 SIGINT 信号
//     pthread_sigmask(SIG_BLOCK, &set, NULL);

//     printf("Thread: SIGINT is blocked\n");

//     // 模拟长时间运行
//     sleep(10);

//     printf("Thread: SIGINT is unblocked\n");

//     return NULL;
// }

// int main()
// {
//     pthread_t thread_id;

//     // 创建线程
//     if (pthread_create(&thread_id, NULL, thread_function, NULL) != 0)
//     {
//         perror("pthread_create");
//         exit(EXIT_FAILURE);
//     }

//     // 主线程继续运行
//     while (1)
//     {
//         printf("Main thread: SIGINT is not blocked\n");
//         sleep(1);
//     }

//     // 等待线程结束
//     pthread_join(thread_id, NULL);

//     return 0;
// }

// #include <stdio.h>
// #include <stdlib.h>
// #include <signal.h>
// #include <unistd.h>
// #include <thread>

// void thread_function()
// {
//     cout << "one thread: " << std::this_thread::get_id() << endl;

//     // 模拟长时间运行
//     while (1)
//     {
//         sleep(1);
//     }
// }

// void handle_sigint(int sig)
// {
//     // printf("Received SIGINT in process %d\n", getpid());
//     std::cout << "Thread ID: " << std::this_thread::get_id() << std::endl;
// }

// int main()
// {
//     // 设置 SIGINT 信号的处理函数
//     signal(SIGINT, handle_sigint);

//     thread th(thread_function);
//     sigset_t set;
//     sigemptyset(&set);
//     sigaddset(&set, SIGINT);
//     pthread_sigmask(SIG_BLOCK, &set, NULL);

//     cout << "Main thread: " << std::this_thread::get_id() << endl;

//     // 主线程继续运行
//     while (1)
//     {
//         sleep(1);
//     }

//     th.join();

//     return 0;
// }

// #include <stdio.h>
// #include <string.h>
// #include <stdlib.h>
// #include <cassert>
// #include <string>
// #include <unistd.h>
// #include <sys/socket.h>
// #include <netinet/in.h>
// #include <arpa/inet.h>
// typedef struct sockaddr sockaddr;
// typedef struct sockaddr_in sockaddr_in;
// class UdpSocket
// {
// public:
//     UdpSocket() : fd_(-1)
//     {
//     }
//     bool Socket()
//     {
//         fd_ = socket(AF_INET, SOCK_DGRAM, 0);
//         if (fd_ < 0)
//         {
//             perror("socket");
//             return false;
//         }
//         return true;
//     }
//     bool Close()
//     {
//         close(fd_);
//         return true;
//     }
//     bool Bind(const std::string &ip, uint16_t port)
//     {
//         sockaddr_in addr;
//         addr.sin_family = AF_INET;
//         // addr.sin_addr.s_addr = inet_addr(ip.c_str());
//         inet_aton(ip.c_str(), &addr.sin_addr); // 将ip串进行转换成点分十进制格式
//         addr.sin_port = htons(port);
//         int ret = bind(fd_, (sockaddr *)&addr, sizeof(addr));
//         if (ret < 0)
//         {
//             perror("bind");
//             return false;
//         }
//         return true;
//     }
//     bool RecvFrom(std::string *buf, std::string *ip = NULL, uint16_t *port = NULL)
//     {
//         char tmp[1024 * 10] = {0};
//         sockaddr_in peer;
//         socklen_t len = sizeof(peer);
//         ssize_t read_size = recvfrom(fd_, tmp,
//                                      sizeof(tmp) - 1, 0, (sockaddr *)&peer, &len);
//         if (read_size < 0)
//         {
//             perror("recvfrom");
//             return false;
//         }
//         // 将读到的缓冲区内容放到输出参数中
//         buf->assign(tmp, read_size);
//         if (ip != NULL)
//         {
//             *ip = inet_ntoa(peer.sin_addr);
//         }
//         if (port != NULL)
//         {
//             *port = ntohs(peer.sin_port);
//         }
//         return true;
//     }
//     bool SendTo(const std::string &buf, const std::string &ip, uint16_t port)
//     {
//         sockaddr_in addr;
//         addr.sin_family = AF_INET;
//         inet_aton(ip.c_str(), &addr.sin_addr);
//         addr.sin_port = htons(port);
//         ssize_t write_size = sendto(fd_, buf.data(), buf.size(), 0, (sockaddr *)&addr, sizeof(addr));
//         if (write_size < 0)
//         {
//             perror("sendto");
//             return false;
//         }
//         return true;
//     }

// private:
//     int fd_;
// };
// #include <arpa/inet.h>
// #include <cstdio>
// #include <thread>

// void print_ip(const char *ip)
// {
//     struct in_addr addr;
//     inet_pton(AF_INET,ip,&addr);
//     char *ip_str = inet_ntoa(addr);
//     printf("%s\n", ip_str);
// }

// int main()
// {
//     std::thread t1(print_ip, "192.168.1.1");
//     std::thread t2(print_ip, "192.168.1.2");
//     t1.join();
//     t2.join();
//     return 0;
// }

// #include <iostream>
// #include <string>
// #include <jsoncpp/json/json.h>
// using namespace std;
// // using namespace Json;

// int main()
// {
//     // Json::Value 万能类型
//     Json::Value root;
//     root["a"] = 10;
//     root["b"] = 20;
//     root["哈哈哈"] = "嘎嘎嘎";
//     // json数据嵌套使用
//     Json::Value tmp;
//     tmp["who"] = "cr";
//     tmp["age"] = 20;
//     root["id"] = tmp;

//     Json::FastWriter writer;       // 行式风格序列化
//     // Json::StyledWriter writer;     // 样式风格序列化
//     string s = writer.write(root); // 将root结构化字段进行序列化操作
//     cout << s << endl;

//     cout << "-------------------------------------" << endl;

//     // 反序列化
//     Json::Value ret;
//     Json::Reader reader;
//     // 调用反序列化方法，将序列化的数据s反序列到ret里
//     if (reader.parse(s, ret)) // 解析root
//     {
//         int a = ret["a"].asInt();
//         int b = root["b"].asInt();
//         string st = root["哈哈哈"].asString();
//         Json::Value data = root["id"];
//         cout << a << ' ' << b << ' ' << st << ' ' << data << endl;
//     }
// }

// #include <stdio.h>
// #include <stdlib.h>

// int main() {
//     // 设置一个新的环境变量
//     if (setenv("MY_VAR", "Hello, World!", 1) != 0) {
//         perror("setenv failed");
//         return 1;
//     }

//     // 获取并打印环境变量的值
//     const char* value = getenv("MY_VAR");
//     if (value) {
//         printf("MY_VAR = %s\n", value);
//     } else {
//         printf("MY_VAR is not set.\n");
//     }

//     // 修改已存在的环境变量
//     if (setenv("MY_VAR", "New Value", 1) != 0) {
//         perror("setenv failed");
//         return 1;
//     }

//     // 再次获取并打印环境变量的值
//     value = getenv("MY_VAR");
//     if (value) {
//         printf("MY_VAR = %s\n", value);
//     } else {
//         printf("MY_VAR is not set.\n");
//     }

//     return 0;
// }

// #include <iostream>
// #include <thread>
// #include <mutex>
// #include <condition_variable>
// using namespace std;

// mutex _mtx;
// condition_variable _cond;
// int g_num = 0;
// void print()
// {
//     {
//         unique_lock<mutex> lck(_mtx);
//         // cout << "i am coming " << this_thread::get_id() << endl;
//         _cond.wait(lck, [&]()
//                    { return g_num > 0; });
//         g_num--;
//     }
//     cout << "i am going " << this_thread::get_id() << endl;
// }
// int main()
// {
//     thread t1(print);
//     thread t2(print);

//     g_num++;
//     _cond.notify_one();

//     t1.join();
//     t2.join();

//     return 0;
// }

// #include <stdio.h>
// #include <stdlib.h>
// #include <string.h>
// #include <unistd.h>
// #include <arpa/inet.h>

// #define PORT 8888
// #define BUFFER_SIZE 1024

// int main()
// {
//     int server_fd, new_socket;
//     struct sockaddr_in address;
//     int opt = 1;
//     int addrlen = sizeof(address);
//     char buffer[BUFFER_SIZE] = {0};

//     // 创建套接字文件描述符
//     if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0)
//     {
//         perror("socket failed");
//         exit(EXIT_FAILURE);
//     }

//     // 设置套接字选项，允许地址重用
//     if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt)))
//     {
//         perror("setsockopt");
//         exit(EXIT_FAILURE);
//     }

//     address.sin_family = AF_INET;
//     address.sin_addr.s_addr = INADDR_ANY;
//     address.sin_port = htons(PORT);

//     // 绑定套接字到指定地址和端口
//     if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)) < 0)
//     {
//         perror("bind failed");
//         exit(EXIT_FAILURE);
//     }

//     // 监听连接
//     if (listen(server_fd, 1) < 0)
//     {
//         perror("listen");
//         exit(EXIT_FAILURE);
//     }

//     printf("Server listening on port %d...\n", PORT);

//     while (1)
//     {
//         sleep(1024);
//         // 接受客户端连接
//         if ((new_socket = accept(server_fd, (struct sockaddr *)&address, (socklen_t *)&addrlen)) < 0)
//         {
//             perror("accept");
//             continue;
//         }

//         printf("New connection accepted.\n");

//         // 接收客户端数据
//         int valread = read(new_socket, buffer, BUFFER_SIZE);
//         if (valread < 0)
//         {
//             perror("read");
//             close(new_socket);
//             continue;
//         }

//         printf("Received: %s\n", buffer);

//         // 将接收到的数据原样返回给客户端
//         send(new_socket, buffer, strlen(buffer), 0);
//         printf("Data sent back to client.\n");

//         // 关闭客户端套接字
//         close(new_socket);
//     }

//     // 关闭服务器套接字
//     close(server_fd);
//     return 0;
// }

// #include <iostream>
// #include <pthread.h>
// #include <unistd.h>
// #include <vector>
// #include <cstdlib>
// #include <ctime>

// // 共享资源
// int shared_data = 0;

// // 读写锁
// pthread_rwlock_t rwlock;

// // 信号量

// // 读者线程函数
// void *Reader(void *arg)
// {
//     //sleep(1); //读者优先，一旦读者进入&&读者很多，写者基本就很难进入了
//     int number = *(int *)arg;
//     while (true)
//     {
//         pthread_rwlock_rdlock(&rwlock); // 读者加锁
//         std::cout << "读者-" << number << " 正在读取数据, 数据是: " << shared_data << std::endl;
//         sleep(1);                       // 模拟读取操作
//         pthread_rwlock_unlock(&rwlock); // 解锁
//     }
//     delete (int*)arg;
//     return NULL;
// }

// // 写者线程函数
// void *Writer(void *arg)
// {
//     int number = *(int *)arg;
//     while (true)
//     {
//         pthread_rwlock_wrlock(&rwlock); // 写者加锁
//         shared_data = rand() % 100;     // 修改共享数据
//         std::cout << "写者- " << number << " 正在写入. 新的数据是: " << shared_data << std::endl;
//         sleep(2);                       // 模拟写入操作
//         pthread_rwlock_unlock(&rwlock); // 解锁

//     }
//     delete (int*)arg;
//     return NULL;
// }

// int main()
// {
//     srand(time(nullptr)^getpid());
//     pthread_rwlock_init(&rwlock, NULL); // 初始化读写锁

//     // 可以更高读写数量配比，观察现象
//     const int reader_num = 2;
//     const int writer_num = 2;
//     const int total = reader_num + writer_num;
//     pthread_t threads[total]; // 假设读者和写者数量相等

//     // 创建读者线程
//     for (int i = 0; i < reader_num; ++i)
//     {
//         int *id = new int(i);
//         pthread_create(&threads[i], NULL, Reader, id);
//     }

//     // 创建写者线程
//     for (int i = reader_num; i < total; ++i)
//     {
//         int *id = new int(i - reader_num);
//         pthread_create(&threads[i], NULL, Writer, id);
//     }

//     // 等待所有线程完成
//     for (int i = 0; i < total; ++i)
//     {
//         pthread_join(threads[i], NULL);
//     }

//     pthread_rwlock_destroy(&rwlock); // 销毁读写锁

//     return 0;
// }

// #include <iostream>
// #include <thread>
// #include <mutex>
// #include <shared_mutex>
// #include <memory>
// #include <vector>
// using namespace std;

// std::shared_mutex rw_mutex;
// int g_val = 1;

// void reader()
// {
//     while (true)
//     {
//         std::shared_lock<std::shared_mutex> lock(rw_mutex);

//         // 读取数据
//         std::cout << "Reader is reading: " << g_val << std::endl;

//         lock.unlock();

//         // std::this_thread::sleep_for(std::chrono::seconds(1));
//     }
// }

// void writer()
// {
//     while (true)
//     {
//         std::unique_lock<std::shared_mutex> lock(rw_mutex);

//         // 写入数据
//         ++g_val;
//         std::cout << "Writer is writing" << std::endl;

//         lock.unlock();

//         // std::this_thread::sleep_for(std::chrono::seconds(1));
//     }
// }

// int main()
// {
//     vector<std::thread> vt1;
//     vector<std::thread> vt2;
//     for (int i = 0; i < 3; i++)
//     {
//         vt1.emplace_back(reader);
//         vt2.emplace_back(writer);
//     }

//     for (int i = 0; i < 3; i++)
//     {
//         vt1[i].join();
//         vt2[i].join();
//     }

//     return 0;
// }

// #include <iostream>
// #include <thread>
// #include <semaphore.h>
// #include <vector>
// using namespace std;

// sem_t read_mutex;
// sem_t write_mutex;
// int reader_count = 0;
// int G_val = 0;

// void reader()
// {
//     while (true)
//     {
//         sem_wait(&read_mutex);
//         reader_count++;
//         if (reader_count == 1)
//         {
//             sem_wait(&write_mutex);
//         }
//         sem_post(&read_mutex);

//         // 读取数据
//         std::cout << "Reader is reading: " << G_val << std::endl;

//         sem_wait(&read_mutex);
//         reader_count--;
//         if (reader_count == 0)
//         {
//             sem_post(&write_mutex);
//         }
//         sem_post(&read_mutex);

//         // std::this_thread::sleep_for(std::chrono::seconds(1));
//     }
// }

// void writer()
// {
//     while (true)
//     {
//         sem_wait(&write_mutex);

//         // 写入数据
//         ++G_val;
//         std::cout << "Writer is writing" << std::endl;

//         sem_post(&write_mutex);

//         // std::this_thread::sleep_for(std::chrono::seconds(1));
//     }
// }

// int main()
// {
//     sem_init(&read_mutex, 0, 1);
//     sem_init(&write_mutex, 0, 1);

//     vector<std::thread> vt1;
//     vector<std::thread> vt2;
//     for (int i = 0; i < 3; i++)
//     {
//         vt1.emplace_back(reader);
//         vt2.emplace_back(writer);
//     }
//     for (int i = 0; i < 3; i++)
//     {
//         vt1[i].join();
//         vt2[i].join();
//     }

//     sem_destroy(&read_mutex);
//     sem_destroy(&write_mutex);

//     return 0;
// }

// 操作共享变量会有问题的售票系统代码
// #include <stdio.h>
// #include <stdlib.h>
// #include <string.h>
// #include <unistd.h>
// #include <pthread.h>
// int ticket = 1000;

// pthread_spinlock_t lock;
// void *route(void *arg)
// {
//     char *id = (char *)arg;
//     while (1)
//     {
//         pthread_spin_lock(&lock);
//         if (ticket > 0)
//         {
//             usleep(1000);
//             printf("%s sells ticket:%d\n", id, ticket);
//             ticket--;
//             pthread_spin_unlock(&lock);
//         }
//         else
//         {
//             pthread_spin_unlock(&lock);
//             break;
//         }
//     }
//     return nullptr;
// }
// int main(void)
// {
//     pthread_spin_init(&lock, PTHREAD_PROCESS_PRIVATE);
//     pthread_t t1, t2, t3, t4;
//     pthread_create(&t1, NULL, route, (void *)"thread 1");
//     pthread_create(&t2, NULL, route, (void *)"thread 2");
//     pthread_create(&t3, NULL, route, (void *)"thread 3");
//     pthread_create(&t4, NULL, route, (void *)"thread 4");
//     pthread_join(t1, NULL);
//     pthread_join(t2, NULL);
//     pthread_join(t3, NULL);
//     pthread_join(t4, NULL);
//     pthread_spin_destroy(&lock);
// }

// #include<iostream>
// #include<vector>
// using namespace std;

// int main()
// {
//     vector<int> v1={1,2,3};
//     vector<int> v2={3,2,1};
//     vector<int> v3={3,2,1};
//     if(v1==v2)
//     {
//         cout<<"v1 = v2"<<endl;
//     }
//     else
//     {
//         cout<<"v1 != v2"<<endl;
//     }

//     if(v2==v3)
//     {
//         cout<<"v3 = v2"<<endl;
//     }
//     else
//     {
//         cout<<"v3 != v2"<<endl;
//     }

//     return 0;
// }

// #include <iostream>
// #include <vector>
// #include <mutex>
// #include <condition_variable>
// #include <memory>
// #include <functional>
// #include <sys/socket.h>
// #include <sys/types.h>
// #include <netinet/in.h>
// #include <arpa/inet.h>
// #include <unistd.h>
// #include <cstring>

// // 网络连接池模板类
// class NetworkConnectionPool
// {
// public:
//     using ConnectionCreator = std::function<int()>;

//     NetworkConnectionPool(int poolSize, ConnectionCreator creator)
//         : poolSize_(poolSize), creator_(creator)
//     {
//         InitializePool();
//     }

//     // 从连接池中获取一个连接
//     int GetConnection()
//     {
//         std::unique_lock<std::mutex> lock(mutex_);
//         condition_.wait(lock, [this]()
//                         { return !availableConnections_.empty(); });
//         int connection = availableConnections_.back();
//         availableConnections_.pop_back();
//         return connection;
//     }

//     // 归还连接到连接池
//     void ReturnConnection(int connection)
//     {
//         std::lock_guard<std::mutex> lock(mutex_);
//         availableConnections_.push_back(connection);
//         condition_.notify_one();
//     }

// private:
//     void InitializePool()
//     {
//         for (int i = 0; i < poolSize_; ++i)
//         {
//             try
//             {
//                 int socket = creator_();
//                 availableConnections_.push_back(socket);
//             }
//             catch (const std::exception &e)
//             {
//                 std::cerr << "Error creating connection: " << e.what() << std::endl;
//             }
//         }
//     }

//     int poolSize_;
//     ConnectionCreator creator_;
//     std::vector<int> availableConnections_;
//     std::mutex mutex_;
//     std::condition_variable condition_;
// };

// // 示例：创建TCP连接
// class TCPConnection
// {
// public:
//     static int CreateTCPConnection(const std::string &host, int port)
//     {
//         int sockfd = socket(AF_INET, SOCK_STREAM, 0);
//         if (sockfd == -1)
//         {
//             perror("Socket creation failed");
//             return -1;
//         }

//         struct sockaddr_in serv_addr;
//         serv_addr.sin_family = AF_INET;
//         serv_addr.sin_port = htons(port);

//         // 将IP地址从字符串转换为二进制形式
//         if (inet_pton(AF_INET, host.c_str(), &serv_addr.sin_addr) <= 0)
//         {
//             perror("Invalid address/ Address not supported");
//             close(sockfd);
//             return -1;
//         }

//         if (connect(sockfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) == -1)
//         {
//             perror("Connection failed");
//             close(sockfd);
//             return -1;
//         }

//         return sockfd;
//     }

//     static void CloseConnection(int socket)
//     {
//         close(socket);
//     }
// };

// int main()
// {
//     // 创建网络连接池
//     auto connectionCreator = []()
//     {
//         return TCPConnection::CreateTCPConnection("127.0.0.1", 8080);
//     };
//     NetworkConnectionPool pool(10, connectionCreator);

//     // 获取连接
//     int socket = pool.GetConnection();
//     if (socket != -1)
//     {
//         // 使用连接发送和接收数据
//         const char *message = "Hello, Server!";
//         send(socket, message, strlen(message), 0);
//         char buffer[1024] = {0};
//         recv(socket, buffer, 1024, 0);
//         std::cout << "Received: " << buffer << std::endl;

//         // 归还连接
//         pool.ReturnConnection(socket);
//     }
//     else
//     {
//         std::cerr << "Failed to get connection from pool" << std::endl;
//     }

//     return 0;
// }

// #include <iostream>
// #include <semaphore.h>
// #include <pthread.h>
// #include <vector>
// #include <unistd.h>
// using namespace std;

// #define default_value 3
// template <class T>
// class annular_queue
// {
// public:
//     annular_queue(size_t n = default_value)
//         : _v(5), _num(n), _proc(0), _cons(0)
//     {
//         sem_init(&_space, 0, n);
//         sem_init(&_data, 0, 0);
//         pthread_mutex_init(&_pmutex, nullptr);
//         pthread_mutex_init(&_cmutex, nullptr);
//     }
//     void push(const T &x)
//     {
//         sem_wait(&_space);            // P操作，分配信号量，成功则-1
//         pthread_mutex_lock(&_pmutex); // 先分配各个线程的信号量，再一个个访问，提高效率
//         _v[_proc++] = x;
//         _proc %= _num;
//         sem_post(&_data); // V操作，数据++
//         pthread_mutex_unlock(&_pmutex);
//     }
//     void pop(T *ret)
//     {
//         sem_wait(&_data); // P操作，分配信号量，成功则-1
//         pthread_mutex_lock(&_cmutex);
//         *ret = _v[_cons++];
//         _cons %= _num;
//         sem_post(&_space); // V操作，数据++
//         pthread_mutex_unlock(&_cmutex);
//     }
//     ~annular_queue()
//     {
//         sem_destroy(&_space);
//         sem_destroy(&_data);
//     }

// private:
//     vector<T> _v;
//     size_t _num;
//     int _proc; // 生产者访问下标
//     int _cons; // 消费者访问下标
//     sem_t _space;
//     sem_t _data;
//     pthread_mutex_t _pmutex;
//     pthread_mutex_t _cmutex;
// };

// // 信号量
// pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
// void *consum(void *args)
// {

//     annular_queue<int> *aq = static_cast<annular_queue<int> *>(args);
//     int ret=0;
//     while (1)
//     {
//         aq->pop(&ret);
//         cout << pthread_self() << " get a data: " << ret << endl;
//     }
//     return nullptr;
// }
// void *produce(void *args)
// {

//     annular_queue<int> *aq = static_cast<annular_queue<int> *>(args);
//     int k = 100; // 公共资源
//     while (k)
//     {
//         pthread_mutex_lock(&mutex);
//         aq->push(k);
//         cout << pthread_self() << " produce a data: " << k << endl;
//         k--;
//         usleep(10000);
//         pthread_mutex_unlock(&mutex);
//     }
//     return nullptr;
// }
// int main()
// {
//     pthread_t tid_1, tid_2, tid_3, tid_4, tid_5;
//     annular_queue<int> *aq = new annular_queue<int>(5);
//     pthread_create(&tid_1, nullptr, consum, aq);
//     pthread_create(&tid_2, nullptr, consum, aq);
//     pthread_create(&tid_3, nullptr, produce, aq);
//     pthread_create(&tid_4, nullptr, produce, aq);
//     pthread_create(&tid_5, nullptr, produce, aq);

//     pthread_join(tid_1, nullptr);
//     pthread_join(tid_2, nullptr);

//     return 0;
// }

// #include <iostream>
// #include <thread>
// #include <mutex>
// #include <condition_variable>
// #include <queue>
// #include <vector>

// std::mutex mtx;               // 互斥锁，保护共享资源
// std::condition_variable cv;   // 条件变量，用于线程间通信
// std::queue<int> shared_queue; // 共享队列，模拟缓冲区
// const int buffer_size = 5;    // 缓冲区大小
// bool production_done = false; // 生产是否完成

// // 生产者函数
// void producer()
// {
//     std::this_thread::sleep_for(std::chrono::milliseconds(100)); // 模拟启动时间
//     for (int i = 1; i <= 10; ++i)
//     { // 生产10个物品
//         std::unique_lock<std::mutex> lock(mtx);
//         cv.wait(lock, []
//                 { return shared_queue.size() < buffer_size; }); // 等待缓冲区有空间
//         shared_queue.push(i);                                   // 将物品放入缓冲区
//         std::cout << "生产者生产了物品 " << i << ", 缓冲区大小: " << shared_queue.size() << std::endl;
//         cv.notify_one(); // 通知消费者
//         lock.unlock();
//         std::this_thread::sleep_for(std::chrono::milliseconds(200)); // 模拟生产时间
//     }
//     {
//         std::lock_guard<std::mutex> lock(mtx);
//         production_done = true; // 标记生产完成
//     }
//     cv.notify_all(); // 通知所有消费者生产已完成
// }

// // 消费者函数
// void consumer(int consumer_id)
// {
//     while (true)
//     {
//         std::unique_lock<std::mutex> lock(mtx);
//         cv.wait(lock, []
//                 { return !shared_queue.empty() || production_done; }); // 等待有物品或生产完成

//         if (!shared_queue.empty())
//         {
//             int item = shared_queue.front();
//             shared_queue.pop();
//             std::cout << "消费者 " << consumer_id << " 消费了物品 " << item << ", 缓冲区大小: " << shared_queue.size() << std::endl;
//             // cv.notify_one(); // 通知生产者
//         }
//         else if (production_done)
//         {
//             break; // 如果生产完成且缓冲区为空，退出循环
//         }
//         lock.unlock();
//         std::this_thread::sleep_for(std::chrono::milliseconds(150)); // 模拟消费时间
//     }
// }

// int main()
// {
//     // std::thread producer_thread(producer);
//     shared_queue.push(1);
//     shared_queue.push(2);
//     shared_queue.push(3);
//     shared_queue.push(4);
//     shared_queue.push(5);

//     std::vector<std::thread> consumer_threads;
//     for (int i = 0; i < 2; ++i)
//     { // 创建2个消费者线程
//         consumer_threads.emplace_back(consumer, i + 1);
//     }

//     // producer_thread.join();
//     sleep(5);
//     production_done=true;
//     cv.notify_all();

//     for (auto &thread : consumer_threads)
//     {
//         thread.join();
//         // cout<<thread.get_id()<<" over"<<endl;
//     }

//     std::cout << "所有物品已被消费，程序结束。" << std::endl;
//     return 0;
// }

// #include <iostream>
// #include <thread>
// #include <mutex>

// std::mutex mutex1, mutex2;

// void thread1()
// {
//     std::cout << "Thread 1 trying to lock mutex1..." << std::endl;
//     mutex1.lock();
//     std::cout << "Thread 1 locked mutex1." << std::endl;
//     sleep(1);

//     std::cout << "Thread 1 trying to lock mutex2..." << std::endl;
//     mutex2.lock();
//     std::cout << "Thread 1 locked mutex2." << std::endl;

//     mutex1.unlock();
//     mutex2.unlock();
// }

// void thread2()
// {
//     std::cout << "Thread 2 trying to lock mutex2..." << std::endl;
//     mutex2.lock();
//     std::cout << "Thread 2 locked mutex2." << std::endl;
//     sleep(1);

//     std::cout << "Thread 2 trying to lock mutex1..." << std::endl;
//     mutex1.lock();
//     std::cout << "Thread 2 locked mutex1." << std::endl;

//     mutex2.unlock();
//     mutex1.unlock();
// }

// int main()
// {
//     std::thread t1(thread1);
//     std::thread t2(thread2);

//     t1.join();
//     t2.join();

//     return 0;
// }

#include <iostream>

class Singleton
{
private:
    static Singleton *instance;
    Singleton()
    {
        std::cout << "Singleton instance created." << std::endl;
    }

public:
    static Singleton *getInstance()
    {
        if (instance == nullptr)
        {
            instance = new Singleton();
        }
        return instance;
    }
    ~Singleton()
    {
        std::cout << "Singleton instance destroyed." << std::endl;
    }
};

Singleton *Singleton::instance = nullptr;

int main()
{
    Singleton *obj = Singleton::getInstance();
    // 单例对象会在程序结束时自动析构
    delete obj;
    return 0;
}